package cn.tedu.game;

import java.util.*;

/**
 * 小Q在进行一场竞技游戏,这场游戏的胜负关键就在于能否能争夺一条长度为L的河道,即可以看作是[0,L]的一条数轴。
 * 这款竞技游戏当中有n个可以提供视野的道具−真视守卫,第i个真视守卫能够覆盖区间[xi,yi]。现在小Q想知道至少用几个真视守卫就可以覆盖整段河道。
 * <p>
 * 输入描述:
 * 输入包括n+1行。
 * 第一行包括两个正整数n和L(1<=n<=10^5,1<=L<=10^9)
 * 接下来的n行,每行两个正整数xi,yi(0<=xi<=yi<=10^9),表示第i个真视守卫覆盖的区间。
 * <p>
 * 输出描述:
 * 一个整数，表示最少需要的真视守卫数量, 如果无解, 输出-1。
 * <p>
 * 输入例子1:
 * 4 6
 * 3 6
 * 2 4
 * 0 2
 * 4 7
 * <p>
 * 输出例子1:
 * 3
 * <p>
 * 解题思路:
 * 按左端点从小到大，右端点从大到小排序，每次看一个区间能里的点往右最大能延伸到哪（mx），下次更新上限（up）的时候就用这个mx。这个过程和leetcode跳跃游戏那题很像。
 */
public class VisionWard {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int count = input.nextInt();
        int max = input.nextInt();
        int[][] visionWards = new int[count][2];
        for (int i = 0; i < count; i++) {
            // 0 左侧范围
            visionWards[i][0] = input.nextInt();
            // 1 右侧范围
            visionWards[i][1] = input.nextInt();
        }

        // Arrays.sort(visionWards, Comparator.comparingInt(a -> a[0]));

        Arrays.sort(visionWards, (a, b) -> {
            if (a[0] == b[0]) {
                return b[1] - a[1];
            }
            return a[0] - b[0];
        });

        if (visionWards[0][0] > 0) {
            System.out.println("-1");
            return;
        }

//        int minCount = put(range, visionWards, 0, 0);
//        System.out.println(minCount);
        greedy(max, visionWards, count);
    }

    /**
     * 动态规划递归解法, 耗时长
     *
     * @param range
     * @param visionWards
     * @param index
     * @param usedCount
     * @return
     */
    private static int put(List<float[]> range, int[][] visionWards, int index, int usedCount) {
        if (range == null || range.size() == 0)
            return usedCount;
        if (index >= visionWards.length)
            return -1;

        // 用当前点
        List<float[]> tmpRange = new ArrayList<>(range);
        tmpRange.removeIf(littleRange -> visionWards[index][0] <= littleRange[0] && littleRange[1] <= visionWards[index][1]);

        // System.out.println("count1 [" + index + "] before");
        int count1 = put(tmpRange, visionWards, index + 1, usedCount + 1);
        // System.out.println("count1 [" + index + "] end = " + count1);

        // 不用当前点
        // System.out.println("count2 [" + index + "] before");
        int count2 = put(range, visionWards, index + 1, usedCount);
        // System.out.println("count2 [" + index + "] end = " + count2);
        if (count1 == -1 && count2 == -1)
            return -1;
        if (count1 == -1)
            return count2;
        if (count2 == -1) {
            // System.out.println("使用了" + index + "节点");
            return count1;
        }
        int min = Math.min(count1, count2);
        // if (min == count1) {
        // System.out.println("使用了" + index + "节点");
        // }
        return min;
    }

    /**
     * 贪心法
     * 按左端点从小到大，右端点从大到小排序，每次看一个区间能里的点往右最大能延伸到哪（mx），
     * 下次更新上限（up）的时候就用这个mx。这个过程和leetcode跳跃游戏那题很像。
     *
     * @param max
     * @param visionWards
     * @param wardCount
     */
    private static void greedy(int max, int[][] visionWards, int wardCount) {
        int up = visionWards[0][1];
        int mx = visionWards[0][1];
        int cnt = 1;
        for (int i = 1; i < wardCount; i++) {
            if (visionWards[i][0] <= up) {
                mx = Math.max(visionWards[i][1], mx);
                if (mx >= max) {
                    System.out.println(cnt + 1);
                    return;
                }
            } else {
                cnt++;
                up = Math.max(up, mx);
                i--;
            }
        }
        if (mx < max) {
            System.out.println("-1");
            return;
        }
        System.out.println(cnt);
    }
}
